package cn.doit.dat06

import javafx.print.Printer

object _03_模式匹配 {
  def main(args: Array[String]): Unit = {

    //值的匹配
    val name = "xianggege"
    name match {
      case a:String if a.startsWith("x")=> println("我不认识你")
      case "lss" => println("你谁啊")
      case "dage" =>println("离我远点")
      case _ => println("你别唑我！！！！")
    }

    //在值匹配的过程中还可以加上守卫模式
    val num = 11
    num match {
      case number:Int if number > 10 => println("a"+number)
      case number:Int if number < 10 => println("b"+number)
      case _ => println("c")
    }

    //匹配类型
    val flag :Any = Array(1,2,3)
    flag match {
      case a:Array[Boolean] => println("如果我能够匹配上，那么我就是一个String类型的值，值是"+a)
      case a:Array[Double] => println("如果我能够匹配上，那么我就是一个double类型的值，值是"+a)
      case a:Array[String] => println("如果我能够匹配上，那么我就是一个int类型的值，值是"+a)
      case a:Array[Int] => println("如果我能够匹配上，那么我就是一个char类型的值，值是"+a)
      case _=>println("啥也不是")
    }

    //在底层去判断的时候，有一个东西叫泛型的擦除
    val list :Any = List(1,2,3)
    list match {
      case a:String =>println("hehe")
      case b:Array[Int]=>println("haha")
      case a:List[Boolean] => println("如果我能够匹配上，那么我就是一个String类型的值，值是"+a)
      case a:List[Double] => println("如果我能够匹配上，那么我就是一个double类型的值，值是"+a)
      case a:List[String] => println("如果我能够匹配上，那么我就是一个int类型的值，值是"+a)
      case a:List[Int] => println("如果我能够匹配上，那么我就是一个char类型的值，值是"+a)
      case _=>println("啥也不是")
    }

    //匹配数组
    val flag1 :Array[Int] = Array(1,2,3)
    flag1 match {
      case Array(1,2) => println("数组是两个元素，并且两个元素的值分别是1和2")
      case Array(_,_) => println("_代表的是占位符，数组的长度是2，并且第二个元素必须值为2，才能匹配上")
      case Array(a,b,c) => println("代表数组的长度是3，具体元素的值是什么，无所谓，只要长度是3就可以"+a+b+c)
      case Array(2,_*) => println("数组的长度至少是一个，但是开头的那个必须是2")
      case Array(1,2,_*) => println("数组的长度至少是3个,并且前面三个元素必须得是1 2 3 ")
      case _ => println("我是兜底的，能不能执行到我这就看命了")
    }

    //匹配集合

    //匹配元祖
    val flag2: Any = (1,"dage",true,"male",'c',18)
    flag2 match {
      case (_,_,'c') => println("判断一下，这是不是一个三元元祖，并且最后一个元素是c")
      case (_,a,b,"male",d,e) => println("是一个6元元祖,并且，第4个元素必须得是male")
      case _ =>println("兜底的")
    }

    //匹配对象  解构匹配
    val peiQi: Pig = Pig(1, "佩奇", 3, 100.88)
    peiQi match {
      case Pig(1,_,_,_) => println("要求这个类型必须得是Pig这个类型，并且id必须得是1")
      case Pig(2,_,_,_) => println("要求这个类型必须得是Pig这个类型，并且id必须得是1")
      case Pig(3,_,_,_) => println("要求这个类型必须得是Pig这个类型，并且id必须得是1")
      case Pig(4,_,_,_) => println("要求这个类型必须得是Pig这个类型，并且id必须得是1")
      case _ =>println("又没有匹配上")
    }

    val pig1: Pig1 = Pig1(1, "佩奇", 3, 100.88)
    pig1 match {
      case Pig1(_) =>
    }

    val arr: Array[(Int, String)] = Array((1, "dage"), (2, "baoming"), (3, "erchuan"), (4, "minghui"), (5, "yuge"))
    for ((_,name) <- arr) {
      println(name)
    }

//    val (id:Int,abc:String)=(1,"dage")
    //==>相当于干了这么一件事情   val id = 1    val abc = "dage"





  }

}

case class Pig(id:Int,name:String,age:Int,weight:Double)

class Pig1(val id:Int,val name:String,val age:Int,val weight:Double)

object Pig1 {

  def apply(id: Int, name: String, age: Int, weight: Double): Pig1 = new Pig1(id, name, age, weight)
  //解构
  def unapply(arg: Pig1): Option[Double] = Some(arg.weight)
}